// #include <iostream>
// #include <string>
// #include <unordered_map>
// #include <variant>
// #include <optional>
// #include <nlohmann/json.hpp>

// using namespace std::string_literals;

// // 定义数据类型集合
// using JsonValue = std::variant<
//     bool,
//     int32_t,
//     int64_t,
//     double,
//     std::string
// >;

// std::unordered_map<std::string, JsonValue> value_map;

// // 类型转换处理器
// JsonValue parse_json_value(const nlohmann::json& j) {
//     if (j.is_boolean()) {
//         return j.get<bool>();
//     }
//     if (j.is_number_float()) {
//         return j.get<double>();
//     }
//     if (j.is_number_integer()) {
//         const int64_t val = j.get<int64_t>();
//         if (val >= std::numeric_limits<int32_t>::min() && 
//             val <= std::numeric_limits<int32_t>::max()) {
//             return static_cast<int32_t>(val);
//         }
//         return val;
//     }
//     if (j.is_string()) {
//         const std::string s = j.get<std::string>();
        
//         // // 尝试转换为整数
//         // try {
//         //     size_t pos;
//         //     const int64_t int_val = std::stoll(s, &pos);
//         //     if (pos == s.size()) {
//         //         if (int_val >= std::numeric_limits<int32_t>::min() && 
//         //             int_val <= std::numeric_limits<int32_t>::max()) {
//         //             return static_cast<int32_t>(int_val);
//         //         }
//         //         return int_val;
//         //     }
//         // } catch (...) {}
        
//         // // 尝试转换为浮点数
//         // try {
//         //     size_t pos;
//         //     const double dbl_val = std::stod(s, &pos);
//         //     if (pos == s.size()) {
//         //         return dbl_val;
//         //     }
//         // } catch (...) {}
        
//         return s;
//     }
//      throw std::runtime_error("Unsupported type: " + std::string(j.type_name()));
// }

// // JSON加载函数
// void load_json(const std::string& json_str) {
//     try {
//         auto j = nlohmann::json::parse(json_str);
        
//         for (auto& [key, value] : j.items()) {
//             try {
//                 value_map[key] = parse_json_value(value);
//             } catch (const std::exception& e) {
//                 std::cerr << "Key '" << key << "' error: " << e.what() << "\n";
//             }
//         }
//     } catch (const nlohmann::json::exception& e) {
//         std::cerr << "JSON解析错误: " << e.what() << "\n";
//     }
// }

// // 数据访问模板
// template<typename T>
// std::optional<T> get_value(const std::string& key) {
//     const auto it = value_map.find(key);
//     if (it == value_map.end()) return std::nullopt;
    
//     try {
//         return std::get<T>(it->second);
//     } catch (const std::bad_variant_access&) {
//         return std::nullopt;
//     }
// }

// // 打印所有数据
// void print_values() {
//     std::cout << "\n当前存储内容 (" << value_map.size() << " 项):\n";
//     for (const auto& [key, val] : value_map) {
//         std::cout << key << " : ";
//         std::visit([](auto&& arg) {
//             using T = std::decay_t<decltype(arg)>;
//             if constexpr (std::is_same_v<T, bool>) {
//                 std::cout << "布尔值: " << std::boolalpha << arg;
//             } else if constexpr (std::is_same_v<T, int32_t>) {
//                 std::cout << "int32: " << arg;
//             } else if constexpr (std::is_same_v<T, int64_t>) {
//                 std::cout << "int64: " << arg;
//             } else if constexpr (std::is_same_v<T, double>) {
//                 std::cout << "浮点数: " << arg;
//             } else if constexpr (std::is_same_v<T, std::string>) {
//                 std::cout << "字符串: \"" << arg << "\"";
//             }
//         }, val);
//         std::cout << "\n";
//     }
// }

// int main() {
//     // 示例JSON数据
//     const std::string json_data = R"(
//         {
//             "active": true,
//             "temperature": 36.6,
//             "max_users": 2147483647,
//             "file_size": 9223372036854775807,
//             "balance": -150.75,
//             "user_id": "12345",
//             "pi_approx": "3.14159",
//             "error_code": "0x1f"
//         }
//     )";

//     // 加载解析JSON
//     load_json(json_data);
    
//     // 演示数据访问
//     if (auto v = get_value<bool>("active")) {
//         std::cout << "系统状态: " << (*v ? "激活" : "关闭") << "\n";
//     }
    
//     if (auto v = get_value<int64_t>("file_size")) {
//         std::cout << "文件大小: " << *v << " 字节\n";
//     }
    
//     if (auto v = get_value<std::string>("error_code")) {
//         std::cout << "错误代码: " << *v << "\n";
//     }
    
//     // 打印所有存储值
//     print_values();

//     return 0;
// }


// maverick@localhost:~$ ./json_parser
// 系统状态: 激活
// 文件大小: 9223372036854775807 字节
// 错误代码: 0x1f

// 当前存储内容 (8 项):
// pi_approx : 字符串: "3.14159"
// temperature : 浮点数: 36.6
// max_users : int32: 2147483647
// user_id : 字符串: "12345"
// error_code : 字符串: "0x1f"
// balance : 浮点数: -150.75
// file_size : int64: 9223372036854775807
// active : 布尔值: true

#include <iostream>
#include <unordered_map>
#include <vector>
#include <string>
#include <thread>
#include <mutex>
#include <random>

struct Property {
    std::string name;
    std::string value;
};

struct Ability {
    std::vector<Property> properties;
};

struct URL {
    std::string nodeid;
};

struct Data {
    URL url;
    Ability ability;
};

std::unordered_map<int, Data> dataMap;
std::mutex dataMutex;

void initializeData() {
    for (int i = 0; i < 30000; ++i) {
        Data data;
        data.url.nodeid = "12345";
        data.ability.properties = {
            {"color", "red"},
            {"size", "large"},
            {"weight", "10"}
        };
        dataMap[i] = data;
    }
}

void deleteRandomData() {
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_int_distribution<> dis(0, 2999);

    for (int i = 0; i < 20; ++i) {
        int key = dis(gen);
        std::lock_guard<std::mutex> guard(dataMutex);
        dataMap.erase(key);
    }
}

void addRandomData() {
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_int_distribution<> dis(3000, 3199);

    for (int i = 0; i < 2000; ++i) {
        int key = dis(gen);
        Data data;
        data.url.nodeid = "12345";
        data.ability.properties = {
            {"color", "blue"},
            {"size", "medium"},
            {"weight", "15"}
        };
        std::lock_guard<std::mutex> guard(dataMutex);
        dataMap[key] = data;
    }
}

// void printData() {
//     std::lock_guard<std::mutex> guard(dataMutex);
//     for (const auto& pair : dataMap) {
//         std::cout << "ID: " << pair.first << "\n";
//         /*std::cout << "  URL NodeID: " << pair.second.url.nodeid << "\n";
//         for (const auto& prop : pair.second.ability.properties) {
//             std::cout << "  Property - Name: " << prop.name << ", Value: " << prop.value << "\n";
//         }*/
//     }
// }

int main() {
    initializeData();

    std::thread deleteThread(deleteRandomData);
    std::thread addThread(addRandomData);
    // std::thread printThread(printData);
    addThread.join();
    deleteThread.join();
    // printThread.join();

    return 0;
}
